home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / cd_mci.exe / CD.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-07  |  13.5 KB  |  611 lines
  1.  
  2. #include <windows.h>
  3. #include <windowsx.h>
  4. #include <mmsystem.h>
  5. #include <toolhelp.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8.  
  9. #include "mci.h"
  10. #include "cd.h"
  11.  
  12. #define TIME_NONE          -999999
  13. #define INI_NAME           "cdplay.ini"
  14. #define INI_TOPIC_NAME     "Names"
  15. #define INI_TOPIC_SETTINGS "Settings"
  16. #define INI_POSITION       "Position"
  17. #define MAX_CDNAME         64
  18.  
  19. HINSTANCE hInst;
  20. char szAppName[] = "CD Player";
  21. BOOL CALLBACK CdDlgProc(HWND hwnd, UINT message,
  22.                         WPARAM wParam, LPARAM lParam);
  23. BOOL CALLBACK TitleDlgProc(HWND hwnd, UINT message,
  24.                            WPARAM wParam, LPARAM lParam);
  25.  
  26. enum CDMode { ModeNotReady, ModePause, ModePlaying, ModeStop, ModeScanning };
  27.  
  28. class CDPlayer : public CDAudio {
  29.    HWND hwnd;
  30.    int nTracks;
  31.    DWORD *PosTracks;    // Positionen der einzelnen Tracks in Millisekunden
  32.    DWORD *LenTracks;    // LΣngen der einzelnen Tracks in Millisekunden
  33.    int Track;           // aktueller Track
  34.    DWORD Sync;          // Systemzeit, bei dem das nΣchste "Sync" stattfindet
  35.    DWORD StartTime;     // Systemzeit, bei dem die CD gestartet wurde
  36.    CDMode mode;         // current status of drive
  37.    DWORD dwPosition;    // always contains the disc position in ms
  38.    WORD wTimer;         // ID of timer used to update display
  39.    char CDTitle[MAX_CDNAME];  // Titel der CD
  40.    char CDID[10];             // ID-String der CD
  41.    BOOL bCountUp;             // count seconds up or down
  42.  
  43. protected:
  44.    DWORD Time();
  45.    int Synchronize(DWORD time = 0);
  46.    void DisplayTime(LONG time, WORD wID);
  47.    void UpdateDisplay(DWORD wTime);
  48.    void CheckReady();
  49.    void SetTrack(int wTrack);
  50.    void SetPosition(DWORD dwPos);
  51.  
  52. public:
  53.    int Timer();
  54.    int Login();          // Betimmt LΣnge der Tracks etc.
  55.    int Logout();         // Setzt die Parameter zurⁿck
  56.    int Resync();
  57.    int Forward();
  58.    int Back();
  59.    int Pause();
  60.    int Play();
  61.    int Stop();
  62.    void ToggleUp();
  63.    void EditTitle();
  64.    CDPlayer(HWND aWindow);
  65.    ~CDPlayer();
  66. };
  67.  
  68.  
  69. char *String(UINT id)
  70. {
  71.    static char szString[128];
  72.  
  73.    if (LoadString(hInst, id, szString, sizeof szString))
  74.       return szString;
  75.    else
  76.       return "";
  77. }
  78.  
  79.  
  80. DWORD MciError(HWND hwnd, DWORD d)
  81. {
  82.    char s[256];
  83.  
  84.    if (d) {
  85.       mciGetErrorString(d, s, sizeof s);
  86.       MessageBox(hwnd, s, szAppName, MB_OK);
  87.    }
  88.     return d;
  89. }
  90.  
  91.  
  92. CDPlayer::CDPlayer(HWND aWindow) : CDAudio(aWindow)
  93. {
  94.    nTracks = 0;
  95.    LenTracks = NULL;
  96.    mode = ModeNotReady;
  97.    Track = 0;
  98.    hwnd = aWindow;
  99.    Sync = 0;
  100.    dwPosition = 0;
  101.    bCountUp = TRUE;
  102.    wTimer = SetTimer(hwnd, 1, 1000, NULL);
  103. }
  104.  
  105.  
  106. CDPlayer::~CDPlayer()
  107. {
  108.    if (wTimer)
  109.       KillTimer(hwnd, 1);
  110. }
  111.  
  112.  
  113. DWORD CDPlayer::Time()
  114. {
  115.    return GetTickCount();
  116. /*
  117.    TIMERINFO ti;
  118.  
  119.    ti.dwSize = sizeof ti;
  120.    TimerCount(&ti);
  121.    return ti.dwmsSinceStart;
  122. */
  123. }
  124.  
  125.  
  126. int CDPlayer::Synchronize(DWORD time)
  127. {
  128.    int t;
  129.    BOOL bPlay;
  130.  
  131.    if (time == 0)
  132.       time = Time();
  133.  
  134.    Sync = time + 5000;
  135.  
  136.    SetTimeFormat(MCI_FORMAT_MILLISECONDS);
  137.    bPlay = Mode() == MCI_MODE_PLAY;
  138.  
  139.    if (mode == ModeNotReady) {
  140.       dwPosition = 0;
  141.       Track = 0;
  142.    }
  143.  
  144.    if (mode == ModePlaying && !bPlay) {
  145.       // CD has stopped
  146.       dwPosition = PosTracks[1];
  147.       Track = 0;
  148.       mode = ModeStop;
  149.    }
  150.    if (bPlay)
  151.       mode = ModePlaying;
  152.  
  153.    if (mode == ModePlaying) {
  154.       dwPosition = Position();
  155.       Track = CurrentTrack();
  156.       StartTime = time - dwPosition;
  157.       if (Sync > StartTime + PosTracks[Track] + LenTracks[Track])
  158.          Sync = StartTime + PosTracks[Track] + LenTracks[Track];
  159.    }
  160.    return TRUE;
  161. }
  162.  
  163.  
  164. void CDPlayer::DisplayTime(LONG time, WORD wID)
  165. {
  166.    char buff[20];
  167.    char buff2[20];
  168.  
  169.    if (time == TIME_NONE) {
  170.       SetDlgItemText(hwnd, wID, " --:--");
  171.       return;
  172.    }
  173.  
  174.    if (time >= 0) {
  175.       time /= 1000;
  176.       wsprintf(buff, " %02d:%02d", int(time / 60), int(time % 60));
  177.    } else {
  178.       time = -(time / 1000) + 1;
  179.       wsprintf(buff, "-%02d:%02d", int(time / 60), int(time % 60));
  180.    }
  181.    GetDlgItemText(hwnd, wID, buff2, sizeof buff2);
  182.    if (strcmp(buff, buff2))
  183.       SetDlgItemText(hwnd, wID, buff);
  184. }
  185.  
  186.  
  187. void CDPlayer::CheckReady()
  188. {
  189.    BOOL bReady = Ready();
  190.  
  191.    if (bReady && mode == ModeNotReady) {
  192.       // CD-Laufwerk ist gerade Ready geworden
  193.       HCURSOR hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
  194.       mode = ModeScanning;
  195.       UpdateDisplay(dwPosition);
  196.       Login();
  197.       SetCursor(hOldCur);
  198.       mode = ModeStop;
  199.       Sync = 0;
  200.    }
  201.  
  202.    if (!bReady && mode != ModeNotReady ) {
  203.       // Laufwerk wurde gerade "gest÷rt"
  204.       Logout();
  205.       mode = ModeNotReady;
  206.       Sync = 0;
  207.    }
  208. }
  209.  
  210.  
  211. int CDPlayer::Resync()
  212. {
  213.    CheckReady();
  214.    Synchronize();
  215.    UpdateDisplay(dwPosition);
  216.    if (wTimer)
  217.       KillTimer(hwnd, 1);
  218.    wTimer = SetTimer(hwnd, 1, 1000, NULL);
  219.    return TRUE;
  220. }
  221.  
  222.  
  223. void CDPlayer::UpdateDisplay(DWORD dwTime)
  224. {
  225.    static char buff[MAX_CDNAME];
  226.    char *s;    // title string to display
  227.    int t;      // track number to display
  228.    static UINT modes[] = {
  229.       IDS_NOTREADY,
  230.       IDS_PAUSED,
  231.       IDS_PLAYING,
  232.       IDS_STOPPED,
  233.       IDS_SCANNING
  234.    };
  235.  
  236.    t = Track;
  237.    s = *CDTitle ? CDTitle : String(modes[mode]);
  238.    if (mode == ModeNotReady || mode == ModeScanning) {
  239.       t = 0;
  240.       s = String(modes[mode]);
  241.       DisplayTime(TIME_NONE, ID_SINGLETIME);
  242.       DisplayTime(TIME_NONE, ID_TOTALTIME);
  243.    } else if (Track == 0) {
  244.       t = nTracks;
  245.       DisplayTime(0, ID_SINGLETIME);
  246.       DisplayTime(PosTracks[nTracks+1], ID_TOTALTIME);
  247.    } else {
  248.       if (bCountUp) {
  249.          DisplayTime(dwTime - PosTracks[Track], ID_SINGLETIME);
  250.          DisplayTime(dwTime - PosTracks[1], ID_TOTALTIME);
  251.       } else {
  252.          DisplayTime(PosTracks[Track+1] - dwTime, ID_SINGLETIME);
  253.          DisplayTime(PosTracks[nTracks+1] - dwTime, ID_TOTALTIME);
  254.       }
  255.    }
  256.  
  257.    if (GetDlgItemInt(hwnd, ID_TRACKCOUNT, NULL, FALSE) != t)
  258.       SetDlgItemInt(hwnd, ID_TRACKCOUNT, t, FALSE);
  259.  
  260.    GetDlgItemText(hwnd, ID_TITLE, buff, sizeof(buff));
  261.    if (strcmp(s, buff))
  262.       SetDlgItemText(hwnd, ID_TITLE, s);
  263. }
  264.  
  265.  
  266. int CDPlayer::Timer()
  267. {
  268.    CheckReady();
  269.  
  270.    DWORD dwTime = Time();
  271.    if (dwTime >= Sync) {
  272.       // Synchronisation required
  273.       Synchronize(dwTime);
  274.    }
  275.  
  276.    if (mode == ModePlaying)
  277.       dwPosition = dwTime - StartTime;
  278.    UpdateDisplay(dwPosition);
  279.    return TRUE;
  280. }
  281.  
  282.  
  283. void CDPlayer::SetTrack(int aTrack)
  284. {
  285.    Track = aTrack;
  286.    SetPosition(PosTracks[Track]);
  287. }
  288.  
  289.  
  290. void CDPlayer::SetPosition(DWORD dwPos)
  291. {
  292.    dwPosition = dwPos;
  293.    if (mode == ModePlaying) {
  294.       SetTimeFormat(MCI_FORMAT_MILLISECONDS);
  295.       MciError(hwnd, CDAudio::Play(MCI_FROM, dwPosition));
  296.    }
  297.    Resync();
  298. }
  299.  
  300.  
  301.  
  302. int CDPlayer::Forward()
  303. {
  304.    int w = Track + 1;
  305.    if (w > nTracks)
  306.       return TRUE;
  307.    SetTrack(w);
  308.    return TRUE;
  309. }
  310.  
  311.  
  312. int CDPlayer::Back()
  313. {
  314.    int w = Track - 1;
  315.    if (w < 1)
  316.       return TRUE;
  317.    SetTrack(w);
  318.    return TRUE;
  319. }
  320.  
  321.  
  322. int CDPlayer::Pause()
  323. {
  324.    if (mode == ModePlaying) {
  325.       SetTimeFormat(MCI_FORMAT_MILLISECONDS);
  326.       dwPosition = Position();
  327.       CDAudio::Stop();
  328.    }
  329.    mode = ModePause;
  330.    Resync();
  331.    return TRUE;
  332. }
  333.  
  334.  
  335. int CDPlayer::Play()
  336. {
  337.    if (mode == ModePlaying) {
  338.       // if playing, play restarts the current song
  339.       dwPosition = PosTracks[Track]; 
  340.    }
  341.    SetTimeFormat(MCI_FORMAT_MILLISECONDS);
  342.    MciError(hwnd, CDAudio::Play(MCI_FROM, dwPosition));
  343.    Resync();
  344.    return TRUE;
  345. }
  346.  
  347.  
  348. int CDPlayer::Stop()
  349. {
  350.    CDAudio::Stop();
  351.    mode = ModeStop;
  352.    SetTrack(0);
  353.    return TRUE;
  354. }
  355.  
  356.  
  357.  
  358. int CDPlayer::Logout()
  359. {
  360.    EnableWindow(GetDlgItem(hwnd, ID_EDIT), FALSE);
  361.    if (LenTracks) {
  362.       delete LenTracks;
  363.       delete PosTracks;
  364.       LenTracks = NULL;
  365.    }
  366.    nTracks = 0;
  367.    Track = 0;
  368.    *CDTitle = '\0';
  369.    return TRUE;
  370. }
  371.  
  372.  
  373. int CDPlayer::Login()
  374. {
  375.    int i;
  376.  
  377.    Logout();
  378.    if (!Ready())
  379.       return FALSE;
  380.  
  381.    nTracks = NumberOfTracks();
  382.    LenTracks = new DWORD[nTracks+1];
  383.    PosTracks = new DWORD[nTracks+2];
  384.  
  385.    SetTimeFormat(MCI_FORMAT_FRAMES);
  386.    long n=Length();
  387.    SetTimeFormat(MCI_FORMAT_MILLISECONDS);
  388.    n=Length();
  389.  
  390.    SetTimeFormat(MCI_FORMAT_MILLISECONDS);
  391.    for (i = 1; i <= nTracks; ++i) {
  392.       PosTracks[i] = Position(i);
  393.    }
  394.    PosTracks[0] = PosTracks[1];
  395.  
  396.    LenTracks[0] = 0;
  397.    for (i = 1; i < nTracks; ++i) {
  398.       LenTracks[i] = PosTracks[i+1] - PosTracks[i];
  399.    }
  400.    LenTracks[nTracks] = Length(i);
  401.    PosTracks[nTracks+1] = PosTracks[nTracks] + LenTracks[nTracks];
  402.    dwPosition = PosTracks[1];
  403.    Track = 0;
  404.  
  405.    wsprintf(CDID, "%08lx", n);
  406.    GetPrivateProfileString(INI_TOPIC_NAME, CDID, String(IDS_DEFAULTNAME),
  407.                            CDTitle, sizeof CDTitle, INI_NAME);
  408.                                        
  409.    if (!Ready()) {
  410.       Logout();
  411.       return FALSE;
  412.    }
  413.    EnableWindow(GetDlgItem(hwnd, ID_EDIT), TRUE);
  414.    return TRUE;
  415. }
  416.  
  417.  
  418. void CDPlayer::EditTitle()
  419. {
  420.    if (DialogBoxParam(hInst, MAKEINTRESOURCE(CDTitleDlg), hwnd,
  421.                      TitleDlgProc, (LPARAM)CDTitle)) {
  422.       WritePrivateProfileString(INI_TOPIC_NAME, CDID, CDTitle, INI_NAME);
  423.       Resync();
  424.    } 
  425. }
  426.  
  427.  
  428. void CDPlayer::ToggleUp()
  429. {
  430.    bCountUp ^= 1;
  431.    Resync();
  432. }
  433.  
  434.  
  435. int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
  436.                    LPSTR lpCmdLine, int nCmdShow)
  437. {
  438.    WNDCLASS wc;
  439.    HWND hwnd;
  440.    MSG msg;
  441.    HINSTANCE hBwcc;
  442.  
  443.    hInst = hInstance;
  444.  
  445.    SetErrorMode(SEM_NOOPENFILEERRORBOX);
  446.    hBwcc = LoadLibrary("BWCC.DLL");
  447.    if ((UINT)hBwcc < 32) {
  448.       MessageBox(NULL, String(IDS_NO_BWCC), szAppName,
  449.                  MB_ICONEXCLAMATION | MB_OK);
  450.       return 0;
  451.    }
  452.  
  453.    hwnd = CreateDialog(hInst, MAKEINTRESOURCE(CDPlayerDlg), NULL, CdDlgProc);
  454.    if (!hwnd)
  455.       return 0;
  456.  
  457.    SetClassWord(hwnd, GCW_HICON, (WORD)LoadIcon(hInst, MAKEINTRESOURCE(CDIcon)));
  458.    ShowWindow(hwnd, nCmdShow);
  459.    UpdateWindow(hwnd);
  460.  
  461.     /* Message Loop */
  462.    while (GetMessage(&msg, NULL, NULL, NULL)) {
  463.        if (!IsDialogMessage(hwnd, &msg)) {
  464.            TranslateMessage(&msg);
  465.            DispatchMessage(&msg);
  466.        }
  467.    }
  468.  
  469.    FreeLibrary(hBwcc);
  470.    return msg.wParam;
  471. }
  472.  
  473.  
  474.  
  475. BOOL CALLBACK _export CdDlgProc(HWND hwnd, UINT message,
  476.                                 WPARAM wParam, LPARAM lParam)
  477. {
  478.    static CDPlayer *cd;
  479.  
  480.    switch (message) {
  481.  
  482.       case WM_INITDIALOG: {
  483.          int x, y;
  484.          char szPos[20];
  485.  
  486.          GetPrivateProfileString(INI_TOPIC_SETTINGS, INI_POSITION, "", szPos,
  487.                                  sizeof szPos, INI_NAME);
  488.          if (sscanf(szPos, "%d %d", &x, &y) == 2)
  489.             SetWindowPos(hwnd, NULL, x, y, 0, 0,
  490.                          SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);      
  491.  
  492.          SetWindowFont(GetDlgItem(hwnd, ID_SINGLETIME), GetStockObject(SYSTEM_FIXED_FONT), FALSE);
  493.          SetWindowFont(GetDlgItem(hwnd, ID_TOTALTIME), GetStockObject(SYSTEM_FIXED_FONT), FALSE);
  494.          EnableWindow(GetDlgItem(hwnd, ID_EDIT), FALSE);
  495.          cd = new CDPlayer(hwnd);
  496.          if (MciError(hwnd, cd->Open("Player", MCI_OPEN_SHAREABLE))) {
  497.             DestroyWindow(hwnd);
  498.          }
  499.  
  500.          return TRUE;
  501.       }
  502.  
  503.       case WM_TIMER:
  504.          cd->Timer();
  505.          break;
  506.  
  507.       case MM_MCINOTIFY:
  508.          cd->Resync();
  509.          break;
  510.  
  511.       case WM_COMMAND:
  512.          switch (wParam) {
  513.  
  514.             case ID_PLAY:
  515.                cd->Play();
  516.                break;
  517.  
  518.             case ID_STOP:
  519.                cd->Stop();
  520.                cd->Resync();
  521.                break;
  522.  
  523.             case ID_PAUSE:
  524.                cd->Pause();
  525.                break;
  526.  
  527.             case ID_FORWARD:
  528.                cd->Forward();
  529.                cd->Resync();
  530.                break;
  531.  
  532.             case ID_BACK:
  533.                cd->Back();
  534.                cd->Resync();
  535.                break;
  536.  
  537.             case ID_QUIT:
  538.                DestroyWindow(hwnd);
  539.                break;
  540.  
  541.             case ID_EDIT:
  542.                cd->EditTitle();
  543.                break;
  544.  
  545.             case ID_UPDOWN:
  546.                cd->ToggleUp();
  547.                break;
  548.          }
  549.          break;
  550.  
  551.       case WM_CLOSE:
  552.          DestroyWindow(hwnd);
  553.          break;
  554.  
  555.       case WM_DESTROY: {
  556.          RECT rc;
  557.          char szPos[20];
  558.  
  559.          GetWindowRect(hwnd, &rc);
  560.          wsprintf(szPos, "%d %d", rc.left, rc.top);
  561.          WritePrivateProfileString(INI_TOPIC_SETTINGS, INI_POSITION, szPos, INI_NAME);
  562.  
  563.          if (cd)
  564.             cd->Close();
  565.          delete cd;
  566.          PostQuitMessage(0);
  567.          break;
  568.       }
  569.       default:
  570.          return FALSE;
  571.    }
  572.    return TRUE;
  573. }
  574.  
  575.  
  576. BOOL CALLBACK _export TitleDlgProc(HWND hwnd, UINT message,
  577.                                    WPARAM wParam, LPARAM lParam)
  578. {
  579.    static char *CDTitle;
  580.    static HWND hwndTitle;
  581.  
  582.    switch (message) {
  583.  
  584.       case WM_INITDIALOG:
  585.          CDTitle = (char *)lParam;
  586.          hwndTitle = GetDlgItem(hwnd, ID_TITLE);
  587.          Edit_LimitText(hwndTitle, MAX_CDNAME-1);
  588.          Edit_SetText(hwndTitle, CDTitle); 
  589.          return TRUE;
  590.  
  591.       case WM_COMMAND:
  592.          switch (wParam) {
  593.              case IDOK:
  594.                 Edit_GetText(hwndTitle, CDTitle, MAX_CDNAME);
  595.                 EndDialog(hwnd, TRUE);
  596.                 break;
  597.  
  598.              case IDCANCEL:
  599.                 EndDialog(hwnd, FALSE);
  600.                 break;
  601.          }
  602.          break;
  603.  
  604.       default:
  605.          return FALSE;
  606.    }
  607.    return TRUE;
  608. }
  609.  
  610.  
  611.